package sanrenxing.score.servlet;

import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import sanrenxing.Paper.dao.PaperDao;
import sanrenxing.score.dao.ScoreDao;
import sanrenxing.score.dao.impl.ScoreDaoImpl;
import sanrenxing.score.domain.Score;
import sanrenxing.score.domain.ScoreTo;
import sun.security.action.PutAllAction;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 功能:成绩servlet
 * 编写者:黄雄珠
 * 创建时间：2020/9/25 19:48
 * 版本:1.0
 */
@WebServlet("/ScoreServlet")
public class ScoreServlet extends HttpServlet {
    //定义数据层对象
    private ScoreDao scoreDao=new ScoreDaoImpl();

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        req.setCharacterEncoding("utf-8");
        resp.setContentType("text/html");
        resp.setCharacterEncoding("utf-8");

        //获得请求路径中的操作方式参数
        String method=req.getParameter("method");
        //判断操作方式，执行方法代码
        if("findAll".equals(method)){
            //调用查询所有数据的方法
            findAll(req,resp);
        }else if("add".equals(method)){
            //调用增加成绩的方法
            add(req,resp);
        }else if("update".equals(method)){
            //调用修改方法
            update(req,resp);
        }else if("batchDel".equals(method)){
            //调用删除方法
            batchDel(req,resp);
        }else if("delete".equals(method)){
            //删除单行
            delete(req,resp);
        }
    }

    /**
     * 批量删除数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void batchDel(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //定义输出流对象
        PrintWriter out=resp.getWriter();

        //得到来自请求中的成绩编号字符串scoreIdStr
        String scoreIdStr=req.getParameter("scoreIdStr");
        //对成绩编号字符串按","进行分割split 定义scoreIds接收
        String[] scoreIds=scoreIdStr.split(",");
        //由于是批量删除，使用异常和循环来进行判断删除是否成功
        try{
            //循环删除 scoreStr
            for(String scoreStr:scoreIds){
                //把字符串转换为整型的成绩编号scoreId
                int scoreId=Integer.parseInt(scoreStr);
                //调用数据层代码进行删除delete
                scoreDao.delete(scoreId);
            }
            //向客户端发送操作结果 成功返回ok  失败返回no
            out.print("ok");
        }catch(Exception e){
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    /**
     * 删除数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void delete(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //定义输出流对象
        PrintWriter out=resp.getWriter();
        //得到来自请求中的成绩编号字符串scoreId 定义scoreIdStr字符串接收
        String scoreIdStr=req.getParameter("scoreId");
        try{
            //把字符串转换为整型的成绩编号scoreId
            int scoreId=Integer.parseInt(scoreIdStr);
            //调用数据层代码进行删除delete
            scoreDao.delete(scoreId);
            //向客户端发送操作结果成功返回ok  失败返回no
            out.print("ok");
        }catch(Exception e){
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    /**
     * 修改成绩表中的成绩数据
     * @param req 请求对象
     * @param resp 响应对象
     * @throws ServletException Servlet异常
     * @throws IOException IO异常
     */
    private void update(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
        //定义输出对象
        PrintWriter out=resp.getWriter();
        //接收来自前端请求的json数据字符串
        String json=req.getParameter("json");
        //定义一个接收科目名称courseName的方法
        String courseName=req.getParameter("courseName");
        //定义Gson操作对象
        Gson gson = new Gson();
        //通过gson对象将json数据转换成对象
        Score score= null;
        try {
            score = gson.fromJson(json, Score.class);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        //调用数据层方法update，实现数据修改 定义rows变量接收
        int rows=scoreDao.update(score);
        //判断操作是否成功
        if(rows>0){
            //获取对象中的分数
            int grades=score.getGrades();
            //获取对象中的成绩编号scoreId
            int scoreId=score.getScoreId();
            //调用数据层scoreId方法通过成绩编号查询学员编号
            String stuId=scoreDao.findStuId(scoreId);
            //判断修改的分数大于等于60分，则调用数据层方法deleteGrades删除学员编号相应的补考学员信息
            if (grades>=60){
                scoreDao.deleteGrades(stuId);
            }else{//修改成绩没有超过60分则调用数据层方法添加补考学院信息
                //调用数据层方法findCourseName通过课程名称获取课程编号
                int courseId=scoreDao.findCourseName(courseName);
                //通过addReexamsMsg方法添加补考学员信息stuId和courseId
                scoreDao.addReexamsMsg(stuId,courseId);
            }
            //操作成功发送ok
            out.print("ok");
        }else{
            //操作失败发送no
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    private void add(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
        //定义输出对象
        PrintWriter out=resp.getWriter();
        //接收来自前端请求的json数据字符串
        String json=req.getParameter("json");
        //定义Gson操作对象
        Gson gson = new Gson();
        //通过gson对象将json数据转换成成绩对象
        Score score= null;
        try {
            score = gson.fromJson(json, Score.class);
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
        }
        //调用数据层方法，实现数据添加 定义rows接收影响的行数
        int rows=scoreDao.add(score);
        //判断操作是否成功rows是否大于0
        if(rows>0){
            out.print("ok");
        }else{
            out.print("no");
        }
        //关闭输出流对象
        out.close();
    }

    /**
     *
     * @param req
     * @param resp
     * @throws ServletException
     * @throws IOException
     */
    private void findAll(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //创建输出流对象
        PrintWriter out = resp.getWriter();
        //获取当前页数
        String pageStr = req.getParameter("page");
        //如果获取的页数为null，则默认为1，如果不为null 则把获取的页数赋值给page
        int page = 1;
        if (pageStr != null && pageStr.trim().length() != 0) {
            page = Integer.parseInt(pageStr);
        }
        //获取每页行数
        //如果获取的行数limit为空 则默认为5 如果不为null，则把获取的行数赋值给rows
        String rowsStr = req.getParameter("limit");
        int rows = 5;
        if (rowsStr != null && rowsStr.trim().length() != 0) {
            rows = Integer.parseInt(rowsStr);
        }
        //定义用于构造多条件查询的对象
        Score score = new Score();
        //获取来自请求中的科目名称courseId
        String courseName = req.getParameter("courseId");
        //判断成绩编号，是否加入到成绩对象中
        if (courseName != null && courseName.trim().length() != 0) {
            //调用findCourseName方法利用科目名称查询科目编号
            int courseId=scoreDao.findCourseName(courseName);
            //修改score对象中的科目编号
            score.setCourseId(courseId);
        }
        //获取来自请求中的学员编号stuId赋值给stuName
        String stuName= req.getParameter("stuId");
        //判断并加入到成绩对象中
        if (stuName != null && stuName.trim().length() != 0) {
            //通过findStuName方法利用学员名字stuName查询到学员编号stuId
            String stuId=scoreDao.findStuName(stuName);
            //修改score对象中的的学员编号
            score.setStuId(stuId);
        }
        //获取来自请求的班级编号classId
        String className = req.getParameter("classId");
        //判断并加入成绩对象中
        if (className != null && className.trim().length() != 0) {
            //使用findClassName通过班级名称查询班级ID
            int classId=scoreDao.findClassName(className);
            //修改score对象中的班级ID
            score.setClassId(classId);
        }
        //调用数据方法，根据成绩对象构造查询条件字符串
        String condition=scoreDao.getCondition(score);
        //执行多条件分页查询
        List<ScoreTo> scoreToList=scoreDao.findByPage(rows,page,condition);
        //多条件查询表中总记录数
        int totalRows=scoreDao.count(condition);

        //定义映射集合对象
       Map<String,Object> mapData=new HashMap<>();
        //在映射集合中添加key为code，值为0的状态码
        mapData.put("code",0);
        //在映射集合中添加key为msg,值为响应信息字符串“”
        mapData.put("msg","");
        //在映射集合中添加key为count,值总行数的数据对totalRows
        mapData.put("count",totalRows);
        //在映射集合中添加key为data,值为员集合对象scoreToList
        mapData.put("data",scoreToList);
        //建立Gson对象
        Gson gson=new Gson();
        //使用Gson对象把映射集合转换为json格式数据定义json1接收
        String json1=gson.toJson(mapData);
        //将json1数据输出到客户端
        out.print(json1);
        //关闭输出流对象
        out.close();
    }
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            this.doGet(req, resp);
        }
}
